home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / madtrb8.arc / DIRSRCH.PAS < prev    next >
Pascal/Delphi Source File  |  1985-02-23  |  5KB  |  143 lines
  1. {$v-}
  2.  
  3.  program dirsrch;
  4. { This program will search a directory for a matching file name
  5.   and then print out it along with its size and attribute byte.
  6.   Other information is available in the record `dta_def'. Using
  7.   the same techniques, if the entry is a directory, it could be
  8.   saved and then searched recursively.
  9.  
  10.          Jim Holtman
  11.          35 Dogwood Trail
  12.          Randolph, NJ 07869
  13.          (201) 361-3395
  14. }
  15.  
  16.     type
  17.        regset = record
  18.           ax,bx,cx,dx,bp,si,di,ds,es,flags : integer;
  19.           end;
  20.        fname = array[1..80] of char;
  21.        str80 = string[80];
  22.        dta_def = record
  23.           filler : array[1..21] of byte;
  24.           attribute : byte;
  25.           file_time : integer;
  26.           file_date : integer;
  27.           file_size : array[1..2] of integer;
  28.           file_name : fname;
  29.           end;
  30.  
  31.     const
  32.        carry = 1;
  33.        directory = $10;
  34.  
  35.     var
  36.        pattern : string[40];
  37.  
  38.     procedure recurse;
  39.  
  40.        var
  41.           dta : dta_def;
  42.           param : regset;
  43.           s_string : string[70];
  44.           r1,r2 : real;
  45.           dta_save : array[1..2] of integer;
  46.           current_directory : string[70];
  47.  
  48. {create a STRING out of the input characters}
  49.  
  50.        function pack_name(var a1;
  51.             size : integer) : str80;
  52.  
  53.           var
  54.              i : integer;
  55.              b : str80;
  56.              a : array[1..1000] of char absolute a1;
  57.  
  58.           begin
  59.              i := 1;
  60.              b := '';
  61.              while (a[i]<>chr(0)) and (i <= size) do begin
  62.                 b := b+a[i];
  63.                 i := i+1;
  64.                 end;
  65.              pack_name := b;
  66.              end;
  67.  
  68.        begin
  69. {          writeln('entering RECURSE');}
  70.                                    {DEBUG}
  71.           with param,dta do begin
  72.              ax := $2F00;          {get DTA}
  73.              msdos(param);
  74.  
  75.              dta_save[1] := es;
  76.              dta_save[2] := bx;
  77.              ax := $1A00;          {set DTA}
  78.              ds := seg(dta);
  79.              dx := ofs(dta);
  80.              msdos(param);
  81.  
  82.              ds := seg(pattern[1]);
  83.              dx := ofs(pattern[1]);
  84.              ax := $4E00;          {find 1st}
  85.              cx := $FF;
  86.              msdos(param);
  87.  
  88.              dx := 0;              {get current directory -- default drive}
  89.              ds := seg(current_directory[1]);
  90.              si := ofs(current_directory[1]);
  91.              ax := $4700;
  92.              msdos(param);
  93.              current_directory := '\'+pack_name(current_directory[1],64);
  94.  
  95.              while (flags and carry) = 0 do begin
  96.                 s_string := pack_name(file_name,sizeof(file_name));
  97.                 if ((attribute and directory) <> 0) and (s_string <> '.') and (
  98.                      s_string <> '..') then begin
  99.                                    {writeln('decending to ',s_string);}
  100.                                    {DEBUG}
  101.                    s_string := s_string+chr(0);
  102.                    ax := $3B00;    {CHDIR}
  103.                    ds := seg(s_string[1]);
  104.                    dx := ofs(s_string[1]);
  105.                    msdos(param);
  106.                    recurse;        {recursive decent into next directory}
  107.                                    {writeln('going back');}
  108.                                    {DEBUG}
  109.                    ax := $3B00;    {go back}
  110.                    s_string := '..'#0;
  111.                                    {go back to `parent'}
  112.                    ds := seg(s_string[1]);
  113.                    dx := ofs(s_string[1]);
  114.                    msdos(param);
  115.                    end
  116.                 else begin
  117.                    r1 := file_size[1];
  118.                    r2 := file_size[2];
  119.                    if r1 < 0 then r1 := r1+65536.0;
  120.                                    {take care of extension of}
  121.                    if r2 < 0 then r2 := r2+65536.0;
  122.                                    {data into the sign bit}
  123.                    s_string := current_directory+'\'+s_string;
  124.                    writeln(s_string, '':(65-length(s_string)),(r2*65536.0+r1):7:
  125.                         0, attribute:3);
  126.                    end;
  127.                 ax := $4F00;       {get next}
  128.                 msdos(param);
  129.                 end;
  130.              ax := $1A00;          {set DTA}
  131.              ds := dta_save[1];
  132.              dx := dta_save[2];
  133.              msdos(param);
  134.              end;
  135.           end;
  136.  
  137.     begin
  138.        write('Pattern to search for - ');
  139.        readln(pattern);
  140.        pattern := pattern+chr(0);
  141.        recurse;
  142.        end.
  143.